/**
 * Store 使用示例
 * 展示如何使用各种存储类和管理器
 */

// 导入存储管理器和各种存储类
import storeManager, { 
  storage, 
  STORAGE_TYPES,
  IndexedStore, 
  LocalStore, 
  SessionStore, 
  MemoryStore 
} from './indexStore.js';

// ============================================
// 1. 基本使用方式
// ============================================

async function basicUsage() {
  // console.log('=== 基本使用方式 ===');
  
  // 使用默认的存储管理器（以 IndexedDB 为主）
  await storage.set('username', 'John Doe');
  const username = await storage.get('username');
  // console.log('用户名:', username);
  
  // 检查键是否存在
  const exists = await storage.has('username');
  // console.log('用户名是否存在:', exists);
  
  // 删除数据
  await storage.remove('username');
  // console.log('删除后用户名:', await storage.get('username', '未找到'));
}

// ============================================
// 2. 指定存储类型
// ============================================

async function specifyStorageType() {
  // console.log('\n=== 指定存储类型 ===');
  
  // 使用 localStorage
  await storage.set('local-data', { type: 'local', value: 123 }, { 
    type: STORAGE_TYPES.LOCAL 
  });
  
  // 使用 sessionStorage
  await storage.set('session-data', { type: 'session', value: 456 }, { 
    type: STORAGE_TYPES.SESSION 
  });
  
  // 使用内存存储
  await storage.set('memory-data', { type: 'memory', value: 789 }, { 
    type: STORAGE_TYPES.MEMORY 
  });
  
  // 使用 IndexedDB（默认）
  await storage.set('indexed-data', { type: 'indexed', value: 999 }, { 
    type: STORAGE_TYPES.INDEXED 
  });
  
  // 读取不同类型的数据
  console.log('Local 数据:', await storage.get('local-data', null, { type: STORAGE_TYPES.LOCAL }));
  console.log('Session 数据:', await storage.get('session-data', null, { type: STORAGE_TYPES.SESSION }));
  console.log('Memory 数据:', await storage.get('memory-data', null, { type: STORAGE_TYPES.MEMORY }));
  console.log('Indexed 数据:', await storage.get('indexed-data', null, { type: STORAGE_TYPES.INDEXED }));
}

// ============================================
// 3. 智能存储（根据数据特性自动选择存储类型）
// ============================================

async function smartStorage() {
  // console.log('\n=== 智能存储 ===');
  
  // 临时缓存数据（自动选择内存存储）
  await storage.smartSet('temp-cache', { data: 'temporary' }, {
    expires: 30000 // 30秒过期，自动使用内存存储
  });
  
  // 会话数据（自动选择 sessionStorage）
  await storage.smartSet('user-session', { token: 'abc123' }, {
    session: true // 会话数据，自动使用 sessionStorage
  });
  
  // 大数据或持久化数据（自动选择 IndexedDB）
  await storage.smartSet('user-profile', {
    id: 1,
    name: 'John Doe',
    avatar: 'data:image/base64,...', // 大数据
    preferences: { theme: 'dark', language: 'zh-CN' }
  }, {
    persistent: true, // 需要持久化
    large: true       // 大数据
  });
  
  // 普通数据（自动选择 localStorage）
  await storage.smartSet('app-settings', { 
    theme: 'light', 
    notifications: true 
  });
  
  console.log('智能存储完成');
}

// ============================================
// 4. 智能获取（从多个存储中查找）
// ============================================

async function smartRetrieval() {
  // console.log('\n=== 智能获取 ===');
  
  // 先在内存中查找，然后是 IndexedDB，最后是 localStorage
  const userData = await storage.smartGet('user-data', null, [
    STORAGE_TYPES.MEMORY,
    STORAGE_TYPES.INDEXED,
    STORAGE_TYPES.LOCAL
  ]);
  
  console.log('智能获取的用户数据:', userData);
  
  // 使用默认搜索顺序
  const settings = await storage.smartGet('app-settings');
  console.log('应用设置:', settings);
}

// ============================================
// 5. 过期时间和自动清理
// ============================================

async function expirationExample() {
  // console.log('\n=== 过期时间示例 ===');
  
  // 设置5秒后过期的数据
  await storage.set('temp-token', 'token123', {
    expires: 5000 // 5秒后过期
  });
  
  console.log('立即获取:', await storage.get('temp-token'));
  
  // 等待6秒后再获取
  setTimeout(async () => {
    console.log('6秒后获取:', await storage.get('temp-token', '已过期'));
  }, 6000);
}

// ============================================
// 6. 批量操作
// ============================================

async function batchOperations() {
  // console.log('\n=== 批量操作 ===');
  
  // 批量设置数据
  const batchData = {
    'user1': { name: 'Alice', age: 25 },
    'user2': { name: 'Bob', age: 30 },
    'user3': { name: 'Charlie', age: 35 }
  };
  
  // 使用内存存储进行批量操作
  const memoryStore = storage.memory;
  await memoryStore.setMany(batchData);
  
  // 批量获取
  const users = await memoryStore.getMany(['user1', 'user2', 'user3']);
  console.log('批量获取的用户:', users);
  
  // 批量删除
  await memoryStore.removeMany(['user2', 'user3']);
  console.log('删除后剩余用户:', await memoryStore.getMany(['user1', 'user2', 'user3']));
}

// ============================================
// 7. 跨存储同步
// ============================================

async function crossStorageSync() {
  // console.log('\n=== 跨存储同步 ===');
  
  // 设置数据并同步到备用存储
  await storage.set('important-data', { 
    id: 1, 
    content: 'This is important!' 
  }, {
    type: STORAGE_TYPES.INDEXED,
    sync: true // 同步到备用存储（localStorage）
  });
  
  // 从备用存储获取数据
  const dataFromLocal = await storage.get('important-data', null, { 
    type: STORAGE_TYPES.LOCAL 
  });
  console.log('从 localStorage 获取的数据:', dataFromLocal);
  
  // 启用备用查找
  const dataWithFallback = await storage.get('some-key', null, { 
    fallback: true // 如果主存储没有，会查找备用存储
  });
  console.log('备用查找结果:', dataWithFallback);
}

// ============================================
// 8. 直接使用各个存储实例
// ============================================

async function directStorageUsage() {
  // console.log('\n=== 直接使用存储实例 ===');
  
  // 直接使用 localStorage
  const localData = { message: 'Hello from localStorage' };
  storage.local.set('direct-local', localData);
  console.log('localStorage 数据:', storage.local.get('direct-local'));
  
  // 直接使用 sessionStorage
  const sessionData = { message: 'Hello from sessionStorage' };
  storage.session.set('direct-session', sessionData);
  console.log('sessionStorage 数据:', storage.session.get('direct-session'));
  
  // 直接使用内存存储
  const memoryData = { message: 'Hello from memory' };
  storage.memory.set('direct-memory', memoryData);
  console.log('Memory 数据:', storage.memory.get('direct-memory'));
  
  // 直接使用 IndexedDB
  await storage.indexed.init(); // 确保已初始化
  await storage.indexed.set('direct-indexed', { message: 'Hello from IndexedDB' });
  console.log('IndexedDB 数据:', await storage.indexed.get('direct-indexed'));
}

// ============================================
// 9. 创建自定义存储实例
// ============================================

async function customStorageInstances() {
  // console.log('\n=== 自定义存储实例 ===');
  
  // 创建自定义的 localStorage 实例
  const userStore = storeManager.createStore(STORAGE_TYPES.LOCAL, 'user');
  userStore.set('profile', { name: 'Custom User', id: 123 });
  console.log('自定义用户存储:', userStore.get('profile'));
  
  // 创建自定义的内存存储实例
  const cacheStore = storeManager.createStore(STORAGE_TYPES.MEMORY, 'cache');
  cacheStore.set('api-response', { data: [1, 2, 3], timestamp: Date.now() });
  console.log('自定义缓存存储:', cacheStore.get('api-response'));
  
  // 创建自定义的 IndexedDB 实例
  const documentStore = storeManager.createStore(STORAGE_TYPES.INDEXED, 'documents');
  await documentStore.init();
  await documentStore.set('doc1', { title: 'Document 1', content: 'Content...' });
  console.log('自定义文档存储:', await documentStore.get('doc1'));
}

// ============================================
// 10. 存储统计和监控
// ============================================

async function storageStats() {
  // console.log('\n=== 存储统计 ===');
  
  // 获取内存存储统计
  const memStats = storage.memory.getStats();
  console.log('内存存储统计:', memStats);
  
  // 获取 localStorage 大小
  const localSize = storage.local.getSize();
  console.log('localStorage 大小:', localSize, 'bytes');
  
  // 获取 sessionStorage 大小
  const sessionSize = storage.session.getSize();
  console.log('sessionStorage 大小:', sessionSize, 'bytes');
  
  // 获取 IndexedDB 统计
  await storage.indexed.init();
  const indexedStats = await storage.indexed.getStats();
  console.log('IndexedDB 统计:', indexedStats);
}

// ============================================
// 11. 错误处理和可用性检查
// ============================================

async function errorHandlingAndAvailability() {
  // console.log('\n=== 错误处理和可用性检查 ===');
  
  // 检查各种存储的可用性
  console.log('localStorage 可用:', storage.local.isAvailable());
  console.log('sessionStorage 可用:', storage.session.isAvailable());
  console.log('Memory 存储可用:', true); // 内存存储总是可用的
  
  // 检查 IndexedDB 可用性
  const indexedAvailable = await storeManager.checkIndexedDBAvailability();
  console.log('IndexedDB 可用:', indexedAvailable);
  
  // 安全的数据操作（自动处理错误）
  try {
    await storage.set('test-key', 'test-value');
    const value = await storage.get('test-key', 'default');
    console.log('安全操作结果:', value);
  } catch (error) {
    console.error('操作失败:', error);
  }
}

// ============================================
// 12. 清理和维护
// ============================================

async function cleanupAndMaintenance() {
  // console.log('\n=== 清理和维护 ===');
  
  // 清理过期数据
  await storage.memory.cleanExpired();
  console.log('内存存储过期数据已清理');
  
  // 清空特定类型的存储
  await storage.clear(STORAGE_TYPES.MEMORY);
  console.log('内存存储已清空');
  
  // 清空所有存储（谨慎使用）
  // await storage.clear();
  // console.log('所有存储已清空');
}

// ============================================
// 运行所有示例
// ============================================

export async function runAllExamples() {
  // console.log('🚀 开始运行 Store 使用示例...\n');
  
  try {
    await basicUsage();
    await specifyStorageType();
    await smartStorage();
    await smartRetrieval();
    await expirationExample();
    await batchOperations();
    await crossStorageSync();
    await directStorageUsage();
    await customStorageInstances();
    await storageStats();
    await errorHandlingAndAvailability();
    await cleanupAndMaintenance();
    
    console.log('\n✅ 所有示例运行完成！');
  } catch (error) {
    console.error('❌ 示例运行出错:', error);
  }
}

// ============================================
// 实际应用场景示例
// ============================================

// 用户认证管理
export class AuthManager {
  static async login(token, userInfo) {
    // 令牌存储在 sessionStorage（会话级别）
    await storage.set('auth-token', token, { 
      type: STORAGE_TYPES.SESSION 
    });
    
    // 用户信息存储在 IndexedDB（持久化）
    await storage.smartSet('user-info', userInfo, { 
      persistent: true 
    });
    
    // 登录状态存储在内存（快速访问）
    await storage.set('is-logged-in', true, { 
      type: STORAGE_TYPES.MEMORY 
    });
  }
  
  static async logout() {
    await storage.remove('auth-token', { type: STORAGE_TYPES.SESSION });
    await storage.remove('is-logged-in', { type: STORAGE_TYPES.MEMORY });
    // 保留用户信息以便下次快速登录
  }
  
  static async isLoggedIn() {
    return await storage.get('is-logged-in', false, { 
      type: STORAGE_TYPES.MEMORY 
    });
  }
}

// 应用配置管理
export class ConfigManager {
  static async saveConfig(config) {
    await storage.smartSet('app-config', config, { 
      persistent: true 
    });
  }
  
  static async getConfig() {
    return await storage.smartGet('app-config', {
      theme: 'light',
      language: 'zh-CN',
      notifications: true
    });
  }
}

// 缓存管理
export class CacheManager {
  static async setCache(key, data, ttl = 300000) { // 默认5分钟
    await storage.set(key, data, {
      type: STORAGE_TYPES.MEMORY,
      expires: ttl
    });
  }
  
  static async getCache(key) {
    return await storage.get(key, null, { 
      type: STORAGE_TYPES.MEMORY 
    });
  }
  
  static async clearExpiredCache() {
    await storage.memory.cleanExpired();
  }
}

// 如果直接运行此文件，执行所有示例
if (typeof window !== 'undefined') {
  // 在浏览器环境中，可以通过控制台运行
  window.runStoreExamples = runAllExamples;
  window.AuthManager = AuthManager;
  window.ConfigManager = ConfigManager;
  window.CacheManager = CacheManager;
  
  // console.log('💡 提示：在控制台中运行 runStoreExamples() 来查看所有示例');
}